/**
 * API服务文件
 * 定义所有的API调用方法
 */
import apiClient from './config.js';

/**
 * 用户认证相关API
 */
export const authApi = {
  /**
   * 用户登录
   * @param {Object} credentials - 登录凭据
   * @param {string} credentials.username - 用户名
   * @param {string} credentials.password - 密码
   * @returns {Promise<Object>} 登录响应数据
   */
  async login(credentials) {
    try {
      const response = await apiClient.post('/api/auth/login', {
        username: credentials.username,
        password: credentials.password
      });
      
      console.log('登录API原始响应:', response);
      console.log('登录API响应数据:', response.data);
      
      // 检查响应格式
      if (response.data && response.data.code === 200) {
        // 标准API响应格式：{ code: 200, message: 'success', data: { user: {...}, token: '...' } }
        return response.data.data;
      } else if (response.data) {
        // 直接返回响应数据
        return response.data;
      } else {
        throw new Error('登录响应格式错误');
      }
    } catch (error) {
      console.error('登录API调用失败:', error);
      
      // 如果是网络错误或服务器不可用，返回模拟数据用于测试
      if (error.code === 'ECONNREFUSED' || error.code === 'NETWORK_ERROR' || 
          (error.response && error.response.status >= 500)) {
        console.log('使用模拟登录数据');
        
        // 模拟登录成功响应
        if (credentials.username === 'admin' && credentials.password === '123456') {
          return {
            user: {
              id: 1,
              username: credentials.username,
              nickname: '管理员',
              email: 'admin@example.com',
              avatar: null,
              role: 'admin',
              createdAt: new Date().toISOString()
            },
            token: 'mock_jwt_token_' + Date.now()
          };
        } else {
          throw new Error('用户名或密码错误');
        }
      }
      
      throw error;
    }
  },

  /**
   * 用户注册
   * @param {Object} userData - 注册数据
   * @param {string} userData.username - 用户名
   * @param {string} userData.password - 密码
   * @param {string} userData.email - 邮箱
   * @param {string} userData.nickname - 昵称
   * @returns {Promise<Object>} 注册响应数据
   */
  async register(userData) {
    const response = await apiClient.post('/api/auth/register', {
      username: userData.username,
      password: userData.password,
      email: userData.email,
      nickname: userData.nickname
    });
    return response.data;
  },

  /**
   * 用户登出
   * @returns {Promise<Object>} 登出响应数据
   */
  async logout() {
    const response = await apiClient.post('/api/auth/logout');
    return response.data;
  },

  /**
   * 获取当前用户信息
   * @returns {Promise<Object>} 用户信息
   */
  async getCurrentUser() {
    const response = await apiClient.get('/api/user/profile');
    return response.data;
  }
};

/**
 * 微信登录相关API
 */
export const wechatApi = {
  /**
   * 生成微信登录二维码
   * @returns {Promise<Object>} 二维码数据
   */
  async generateQR() {
    const response = await apiClient.post('/api/wechat/qr-generate');
    return response.data;
  },

  /**
   * 检查微信扫码状态
   * @param {string} qrId - 二维码ID
   * @returns {Promise<Object>} 扫码状态数据
   */
  async checkScanStatus(qrId) {
    const response = await apiClient.get(`/api/wechat/scan-status/${qrId}`);
    return response.data;
  }
};

/**
 * 用户信息相关API
 */
export const userApi = {
  /**
   * 获取用户信息
   * @returns {Promise<Object>} 用户信息
   */
  async getProfile() {
    const response = await apiClient.get('/api/user/profile');
    return response.data;
  },

  /**
   * 更新用户信息
   * @param {Object} userInfo - 用户信息
   * @param {string} userInfo.nickname - 昵称
   * @param {string} userInfo.email - 邮箱
   * @param {string} userInfo.avatar - 头像URL
   * @returns {Promise<Object>} 更新后的用户信息
   */
  async updateProfile(userInfo) {
    const response = await apiClient.put('/api/user/profile', userInfo);
    return response.data;
  },

  /**
   * 获取用户作品列表
   * @param {Object} params - 查询参数
   * @param {number} params.page - 页码
   * @param {number} params.limit - 每页数量
   * @param {string} params.category - 作品分类
   * @param {string} params.sort - 排序方式
   * @returns {Promise<Object>} 作品列表数据
   */
  async getWorks(params = {}) {
    const response = await apiClient.get('/api/user/works', {
      params: {
        page: params.page || 1,
        limit: params.limit || 10,
        category: params.category,
        sort: params.sort || 'latest'
      }
    });
    return response.data;
  },

  /**
   * 上传作品
   * @param {FormData} formData - 作品数据（包含文件）
   * @returns {Promise<Object>} 上传结果
   */
  async uploadWork(formData) {
    const response = await apiClient.post('/api/user/works', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    });
    return response.data;
  },

  /**
   * 删除作品
   * @param {number} workId - 作品ID
   * @returns {Promise<Object>} 删除结果
   */
  async deleteWork(workId) {
    const response = await apiClient.delete(`/api/user/works/${workId}`);
    return response.data;
  },

  /**
   * 更新作品信息
   * @param {number} workId - 作品ID
   * @param {Object} workData - 作品数据
   * @param {string} workData.title - 作品标题
   * @param {string} workData.description - 作品描述
   * @param {Array<string>} workData.tags - 标签数组
   * @returns {Promise<Object>} 更新结果
   */
  async updateWork(workId, workData) {
    const response = await apiClient.put(`/api/user/works/${workId}`, workData);
    return response.data;
  }
};

/**
 * 竞赛相关API
 */
export const contestApi = {
  /**
   * 获取竞赛列表
   * @param {Object} params - 查询参数
   * @param {number} params.page - 页码
   * @param {number} params.limit - 每页数量
   * @param {string} params.status - 竞赛状态
   * @returns {Promise<Object>} 竞赛列表数据
   */
  async getContests(params = {}) {
    try {
      const response = await apiClient.get('/api/contests', {
        params: {
          page: params.page || 1,
          limit: params.limit || 10,
          status: params.status
        }
      });
      return response.data;
    } catch (error) {
      console.error('获取竞赛列表API调用失败，使用模拟数据:', error);
      // 返回模拟竞赛数据
      return {
        contests: [
          {
            id: 1,
            title: 'AI创意设计大赛2024',
            description: '展示你的AI创意设计能力，创造令人惊叹的视觉作品',
            status: 'active',
            startDate: '2024-01-15',
            endDate: '2024-03-15',
            participants: 156,
            maxParticipants: 500,
            prize: '总奖金池10万元',
            category: 'design'
          },
          {
            id: 2,
            title: 'AI编程挑战赛',
            description: '用AI技术解决实际编程问题，展示你的算法能力',
            status: 'upcoming',
            startDate: '2024-02-01',
            endDate: '2024-04-01',
            participants: 89,
            maxParticipants: 300,
            prize: '冠军奖金5万元',
            category: 'programming'
          },
          {
            id: 3,
            title: 'AI写作创作大赛',
            description: '结合AI工具进行创意写作，探索文学创作新可能',
            status: 'active',
            startDate: '2024-01-20',
            endDate: '2024-03-20',
            participants: 234,
            maxParticipants: 400,
            prize: '优秀作品将获得出版机会',
            category: 'writing'
          },
          {
            id: 4,
            title: 'AI视频制作大赛',
            description: '使用AI工具制作创意视频，展现视觉艺术魅力',
            status: 'ended',
            startDate: '2023-11-01',
            endDate: '2023-12-31',
            participants: 178,
            maxParticipants: 250,
            prize: '最佳创意奖3万元',
            category: 'video'
          }
        ],
        pagination: {
          page: params.page || 1,
          pageSize: params.limit || 10,
          total: 4,
          totalPages: 1
        }
      };
    }
  },

  /**
   * 获取竞赛详情
   * @param {number} contestId - 竞赛ID
   * @returns {Promise<Object>} 竞赛详情数据
   */
  async getContestDetail(contestId) {
    const response = await apiClient.get(`/api/contests/${contestId}`);
    const contestData = response.data;
    
    // 如果用户已登录，尝试获取用户的参与状态
     try {
       const token = localStorage.getItem('token');
       if (token && contestData) {
         // 尝试获取用户参与状态
         const statusResponse = await apiClient.get(`/api/contests/${contestId}/status`);
        //  console.log(statusResponse.data, 6666666666666666);
         if (statusResponse.data || statusResponse.data.data) {
            // 映射后端字段到前端期望的字段名
            const statusData = statusResponse.data;
            
            // 基础参与状态
            contestData.isJoined = statusData.is_participated || false;
            
            // 扩展状态信息
            contestData.canJoin = statusData.can_join || false;
            contestData.canSubmit = statusData.can_submit || false;
            contestData.hasSubmittedWork = statusData.has_submitted_work || false;
            contestData.participationStatus = statusData.participation_status || null;
            contestData.participationDate = statusData.participation_date || null;
            contestData.submittedWorkId = statusData.submitted_work_id || null;
            contestData.submittedWorkTitle = statusData.submitted_work_title || null;
            contestData.submissionDate = statusData.submission_date || null;
            
            // 优化提交作品按钮显示逻辑
            console.log(contestData.canJoin,contestData.canSubmit,contestData.hasSubmittedWork,contestData.status, 677777)
            // 只有在用户已参与竞赛、竞赛进行中、可以提交且未提交作品时才显示提交按钮
            contestData.showSubmitButton = !contestData.isJoined && 
                                         contestData.canSubmit && 
                                         !contestData.hasSubmittedWork && 
                                         (contestData.status === 'active' || contestData.status === 'ongoing');
            
            console.log('=== 用户参与状态获取成功 ===');
            console.log('status接口返回:', statusResponse.data);
            console.log('映射后的状态信息:');
            console.log('  isJoined:', contestData.isJoined);
            console.log('  canJoin:', contestData.canJoin);
            console.log('  canSubmit:', contestData.canSubmit);
            console.log('  hasSubmittedWork:', contestData.hasSubmittedWork);
            console.log('  showSubmitButton:', contestData.showSubmitButton);
            console.log('  participationStatus:', contestData.participationStatus);
            console.log('============================');
          }
       } else {
         // 用户未登录时的默认状态
         contestData.isJoined = false;
         contestData.canJoin = false;
         contestData.canSubmit = false;
         contestData.hasSubmittedWork = false;
         contestData.showSubmitButton = false;
       }
     } catch (error) {
       // 如果获取参与状态失败，不影响主要的竞赛详情获取
       console.warn('获取用户参与状态失败:', error);
       if (contestData && typeof contestData.isJoined === 'undefined') {
         contestData.isJoined = false;
         contestData.canJoin = false;
         contestData.canSubmit = false;
         contestData.hasSubmittedWork = false;
         contestData.showSubmitButton = false;
       }
     }
    
    return contestData;
  },

  /**
   * 参加竞赛
   * @param {number} contestId - 竞赛ID
   * @returns {Promise<Object>} 参加结果
   */
  async joinContest(contestId) {
    const response = await apiClient.post(`/api/contests/${contestId}/join`);
    return response.data;
  },

  /**
   * 退出竞赛
   * @param {number} contestId - 竞赛ID
   * @returns {Promise<Object>} 退出结果
   */
  async leaveContest(contestId) {
    const response = await apiClient.post(`/api/contests/${contestId}/leave`);
    return response.data;
  },

  /**
   * 提交竞赛作品
   * @param {number} contestId - 竞赛ID
   * @param {FormData} formData - 作品数据（包含文件）
   * @returns {Promise<Object>} 提交结果
   */
  async submitWork(contestId, formData) {
    const response = await apiClient.post(`/api/contests/${contestId}/works`, formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    });
    return response.data;
  },

  /**
   * 获取竞赛作品列表
   * @param {number} contestId - 竞赛ID
   * @param {Object} params - 查询参数
   * @param {number} params.page - 页码
   * @param {number} params.limit - 每页数量
   * @param {string} params.sort - 排序方式
   * @returns {Promise<Object>} 作品列表数据
   */
  async getContestWorks(contestId, params = {}) {
    const response = await apiClient.get(`/api/contests/${contestId}/works`, {
      params: {
        page: params.page || 1,
        limit: params.limit || 10,
        sort: params.sort || 'latest'
      }
    });
    return response.data;
  },

  /**
   * 为竞赛作品投票/点赞
   * @param {number} workId - 作品ID
   * @returns {Promise<Object>} 投票结果
   */
  async voteWork(workId) {
    const response = await apiClient.post(`/api/works/${workId}/vote`);
    return response.data;
  },

  /**
   * 获取我参加的竞赛
   * @param {Object} params - 查询参数
   * @param {number} params.page - 页码
   * @param {number} params.limit - 每页数量
   * @param {string} params.status - 竞赛状态
   * @returns {Promise<Object>} 我的竞赛列表
   */
  async getMyContests(params = {}) {
    const response = await apiClient.get('/api/user/contests', {
      params: {
        page: params.page || 1,
        limit: params.limit || 10,
        status: params.status
      }
    });
    return response.data;
  }
};

/**
 * 分类相关API
 */
export const categoryApi = {
  /**
   * 获取所有分类列表
   * @returns {Promise<Array>} 分类列表
   */
  async getCategories() {
    try {
      const response = await apiClient.get('/api/search/categories');
      return response.data.categories || [];
    } catch (error) {
      console.error('获取分类失败:', error);
      // 返回默认分类作为备选
      return [
        { value: 'design', label: '设计类', description: '平面设计、UI/UX设计等' },
        { value: 'video', label: '视频类', description: '视频制作、动画设计等' },
        { value: 'programming', label: '编程类', description: '软件开发、算法设计等' },
        { value: 'writing', label: '写作类', description: '文案创作、内容写作等' },
        { value: 'photography', label: '摄影类', description: '摄影作品、图片处理等' },
        { value: 'music', label: '音乐类', description: '音乐创作、音频制作等' },
        { value: 'innovation', label: '创新类', description: '创新方案、产品设计等' },
        { value: 'other', label: '其他', description: '其他类型作品' }
      ];
    }
  }
};

/**
 * 搜索相关API
 */
export const searchApi = {
  /**
   * 搜索AI工具
   * @param {Object} params - 搜索参数
   * @param {string} params.q - 搜索关键词（必填）
   * @param {number} params.page - 页码（默认1）
   * @param {number} params.limit - 每页数量（默认10，范围1-50）
   * @param {string} params.category - 工具分类过滤（可选）
   * @param {string} params.sort - 排序方式（默认relevance）
   * @returns {Promise<Object>} 搜索结果数据
   */
  async searchTools(params) {
    const response = await apiClient.get('/api/search/tools', {
      params: {
        q: params.keyword || params.q,
        page: params.page || 1,
        limit: Math.min(params.limit || 10, 50), // 限制最大50
        category: params.category,
        sort: params.sort || 'relevance'
      }
    });
    return response.data;
  },

  /**
   * 获取热门搜索关键词
   * @param {number} limit - 返回数量（默认10，范围1-20）
   * @returns {Promise<Object>} 热门关键词数据
   */
  async getHotKeywords(limit = 10) {
    try {
      const response = await apiClient.get('/api/search/trending', {
        params: { limit: Math.min(limit, 20) } // 限制最大20
      });
      // console.log('API返回的热门关键词数据:', response.data);
      return response.data;
    } catch (error) {
      console.error('获取热门关键词失败:', error);
      // 返回默认热门关键词
      return {
        keywords: ['ChatGPT', 'Midjourney', '文心一言', 'Stable Diffusion', 'Claude']
      };
    }
  },

  /**
   * 获取搜索建议
   * @param {string} q - 搜索关键词前缀（必填，至少2个字符）
   * @param {number} limit - 返回数量（默认5，范围1-10）
   * @returns {Promise<Object>} 搜索建议数据
   */
  async getSuggestions(q, limit = 5) {
    if (!q || q.length < 2) {
      return { suggestions: [] };
    }
    
    try {
      const response = await apiClient.get('/api/search/suggestions', {
        params: { 
          q: q.trim(), 
          limit: Math.min(limit, 10) // 限制最大10
        }
      });
      return response.data;
    } catch (error) {
      console.error('获取搜索建议失败:', error);
      return { suggestions: [] };
    }
  },

  /**
   * 获取工具分类
   * @returns {Promise<Object>} 工具分类数据
   */
  async getCategories() {
    try {
      const response = await apiClient.get('/api/search/categories');
      return response.data;
    } catch (error) {
      console.error('获取工具分类失败:', error);
      // 返回默认分类
      return {
        categories: [
          { name: '对话', count: 15 },
          { name: '图像', count: 12 },
          { name: '写作', count: 8 },
          { name: '编程', count: 6 },
          { name: '音频', count: 4 }
        ]
      };
    }
  },

  /**
   * 获取热门工具
   * @param {number} limit - 返回数量（默认10，范围1-20）
   * @param {string} category - 分类过滤（可选）
   * @returns {Promise<Object>} 热门工具数据
   */
  async getPopularTools(limit = 10, category = '') {
    try {
      const response = await apiClient.get('/api/search/popular', {
        params: { 
          limit: Math.min(limit, 20), // 限制最大20
          category: category
        }
      });
      return response.data;
    } catch (error) {
      console.error('获取热门工具失败:', error);
      return { tools: [] };
    }
  },

  /**
   * 记录工具点击
   * @param {number} toolId - AI工具的唯一标识ID
   * @returns {Promise<Object>} 记录结果
   */
  async recordClick(toolId) {
    // 如果toolId无效，直接返回成功（避免API错误）
    if (!toolId || typeof toolId !== 'number') {
      console.warn('无效的工具ID，跳过点击记录:', toolId);
      return { success: true, message: '跳过记录' };
    }
    
    try {
      const response = await apiClient.post('/api/search/record-click', {
        tool_id: toolId
      });
      return response.data;
    } catch (error) {
      console.error('记录工具点击失败:', error);
      // 不抛出错误，避免影响用户体验
      return { success: false, error: error.message };
    }
  },

  // 兼容旧版本的方法名
  async getSearchSuggestions(keyword, limit = 5) {
    return this.getSuggestions(keyword, limit);
  },

  async getTrendingKeywords(limit = 10) {
    const result = await this.getHotKeywords(limit);
    return result.keywords || [];
  },

  // 通用搜索方法（兼容现有代码）
  async search(params) {
    return this.searchTools(params);
  }
};

/**
 * 文件上传相关API
 */
export const uploadApi = {
  /**
   * 上传头像
   * @param {File} file - 头像文件
   * @returns {Promise<string>} 头像URL
   */
  async uploadAvatar(file) {
    const formData = new FormData();
    formData.append('avatar', file);
    
    const response = await apiClient.post('/api/upload/avatar', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    });
    return response.data.url;
  },

  /**
   * 上传作品文件
   * @param {File} file - 作品文件
   * @param {string} type - 文件类型
   * @param {Function} onProgress - 上传进度回调
   * @returns {Promise<Object>} 上传结果
   */
  async uploadWorkFile(file, type, onProgress) {
    const formData = new FormData();
    formData.append('file', file);
    formData.append('type', type);
    
    const response = await apiClient.post('/api/upload/work', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      },
      onUploadProgress: (progressEvent) => {
        if (onProgress) {
          const progress = Math.round(
            (progressEvent.loaded * 100) / progressEvent.total
          );
          onProgress(progress);
        }
      }
    });
    return response.data;
  }
};

/**
 * 分页处理工具函数
 * @param {Function} fetchFunction - 数据获取函数
 * @returns {Object} 分页相关的状态和方法
 */
export const usePagination = (fetchFunction) => {
  const state = {
    data: [],
    loading: false,
    pagination: {
      page: 1,
      limit: 10,
      total: 0
    }
  };
  
  const fetchData = async (page = 1) => {
    state.loading = true;
    try {
      const result = await fetchFunction({ 
        page, 
        limit: state.pagination.limit 
      });
      
      state.data = result.data || result.works || result.contests || result.results || [];
      state.pagination = {
        page: result.page || page,
        limit: result.limit || state.pagination.limit,
        total: result.total || 0
      };
    } catch (error) {
      console.error('数据获取失败:', error);
      state.data = [];
    } finally {
      state.loading = false;
    }
  };
  
  return { state, fetchData };
};